home *** CD-ROM | disk | FTP | other *** search
/ MACD 5 / MACD 5.bin / workbench / boot / czesc_2 / snap / clip.c < prev    next >
C/C++ Source or Header  |  1995-09-04  |  4KB  |  195 lines
  1.  
  2. #include "Snap.h"
  3.  
  4. /* This is just plain clipboard handling */
  5. #include <setjmp.h>
  6.  
  7. /* alredy defined in Include 2.0 
  8. #define ID(a,b,c,d) ((a << 24L) | (b << 16L) | (c << 8L) | (d))
  9.  
  10. #define ID_CAT  ID('C','A','T',' ')
  11. #define ID_FORM ID('F','O','R','M')
  12. #define ID_FTXT ID('F','T','X','T')
  13. #define ID_CHRS ID('C','H','R','S')
  14. */
  15.  
  16. #define SAFE(cond, jmp_buf)  { if (!(cond)) longjmp(jmp_buf,-1); }
  17.  
  18. IMPORT struct IOClipReq *ClipReq;
  19.  
  20. VOID CBFInit(struct CBFHandle *CBFH)
  21. {
  22.     if (CBFH->Type == CBFCLIP)
  23.     {
  24.         CBFH->Handle.ClipReq->io_Error = 0;
  25.         CBFH->Handle.ClipReq->io_Offset = 0L;
  26.         CBFH->Handle.ClipReq->io_ClipID = 0L;
  27.     }
  28. }
  29.  
  30. VOID CBFEndWrite(struct CBFHandle *CBFH)
  31. {
  32.     if (CBFH->Type == CBFCLIP)
  33.     {
  34.         CBFH->Handle.ClipReq->io_Command = CMD_UPDATE;
  35.         DoIO((struct IORequest *)CBFH->Handle.ClipReq);
  36.     }
  37. }
  38.  
  39. VOID CBFEndRead(struct CBFHandle *CBFH)
  40. {
  41.     if (CBFH->Type == CBFCLIP)
  42.     {
  43.         CBFH->Handle.ClipReq->io_Command = CMD_READ;
  44.         CBFH->Handle.ClipReq->io_Offset = 2000000000;
  45.         CBFH->Handle.ClipReq->io_Length = 1;
  46.         CBFH->Handle.ClipReq->io_Data = (STRPTR) 0;
  47.         DoIO((struct IORequest *)CBFH->Handle.ClipReq);
  48.     }
  49. }
  50.  
  51. ULONG CBFSeek(struct CBFHandle *CBFH, LONG Offset, LONG Origin)
  52. {
  53.     if (CBFH->Type == CBFCLIP)
  54.     {
  55.         switch (Origin)
  56.         {
  57.         case OFFSET_CURRENT:
  58.             {
  59.                 CBFH->Handle.ClipReq->io_Offset += Offset;
  60.                 return CBFH->Handle.ClipReq->io_Offset;
  61.             }
  62.         case OFFSET_BEGINNING:
  63.             {
  64.                 CBFH->Handle.ClipReq->io_Offset = Offset;
  65.                 return CBFH->Handle.ClipReq->io_Offset;
  66.             }
  67.         default:
  68.             {
  69.                 return 2000000000;
  70.             }
  71.         }
  72.     }
  73.     else
  74.     {
  75.         return (ULONG) Seek(CBFH->Handle.File, Offset, Origin);
  76.     }
  77.     return 0;
  78. }
  79.  
  80. LONG CBFWrite(struct CBFHandle * CBFH, STRPTR Buf, ULONG BufSize)
  81. {
  82.     if (CBFH->Type == CBFCLIP)
  83.     {
  84.         CBFH->Handle.ClipReq->io_Command = CMD_WRITE;
  85.         CBFH->Handle.ClipReq->io_Data = Buf;
  86.         CBFH->Handle.ClipReq->io_Length = BufSize;
  87.         DoIO((struct IORequest *)CBFH->Handle.ClipReq);
  88.         return (CBFH->Handle.ClipReq->io_Error ? -1 : 0);
  89.     }
  90.     else
  91.     {
  92.         return Write(CBFH->Handle.File, (char *)Buf, BufSize);
  93.     }
  94. }
  95.  
  96. LONG CBFRead(struct CBFHandle *CBFH, STRPTR Buf, ULONG BufSize)
  97. {
  98.     if (CBFH->Type == CBFCLIP)
  99.     {
  100.         CBFH->Handle.ClipReq->io_Command = CMD_READ;
  101.         CBFH->Handle.ClipReq->io_Data = Buf;
  102.         CBFH->Handle.ClipReq->io_Length = BufSize;
  103.         DoIO((struct IORequest *)CBFH->Handle.ClipReq);
  104.         return (CBFH->Handle.ClipReq->io_Error ? -1 : 0);
  105.     }
  106.     else
  107.     {
  108.         return Read(CBFH->Handle.File, (char *)Buf, BufSize);
  109.     }
  110. }
  111.  
  112. jmp_buf failure;
  113.  
  114. VOID SaveClip(UBYTE * SnapSpace, ULONG SnapSize)
  115. {
  116.     ULONG Len;
  117.     struct CBFHandle CBFH;
  118.  
  119.     CBFH.Type = CBFCLIP;
  120.     CBFH.Handle.ClipReq = ClipReq;
  121.  
  122.     CBFInit(&CBFH);
  123.     CBFWrite(&CBFH, (STRPTR) "FORM", 4L);
  124.     Len = (SnapSize + 13) & ~1;
  125.     CBFWrite(&CBFH, (STRPTR) & Len, 4L);
  126.     CBFWrite(&CBFH, (STRPTR) "FTXT", 4L);
  127.     CBFWrite(&CBFH, (STRPTR) "CHRS", 4L);
  128.     Len = SnapSize;
  129.     CBFWrite(&CBFH, (STRPTR) & Len, 4L);
  130.     CBFWrite(&CBFH, SnapSpace, Len);
  131.     if (SnapSize & 1)
  132.     {
  133.         CBFWrite(&CBFH, (STRPTR) "\0", 1L);
  134.     }
  135.     CBFEndWrite(&CBFH);
  136. }
  137.  
  138. struct Snap *FetchClip()
  139. {
  140.     struct Snap *Snap = NULL;
  141.     ULONG ID[3];
  142.     struct CBFHandle CBFH;
  143.     WORD done = 0;
  144.  
  145.     CBFH.Type = CBFCLIP;
  146.     CBFH.Handle.ClipReq = ClipReq;
  147.  
  148.     if (setjmp(failure))
  149.     {
  150.         if (Snap)
  151.         {
  152.             FreeMem(Snap, Snap->Size);
  153.         }
  154.         CBFEndRead(&CBFH);
  155.         return NULL;
  156.     }
  157.  
  158.     CBFInit(&CBFH);
  159.     SAFE(CBFRead(&CBFH, (STRPTR) & ID[0], 12) != -1L, failure);
  160.     if (ID[0] != ID_CAT)
  161.     {
  162.         CBFSeek(&CBFH, -12, OFFSET_CURRENT);
  163.     }
  164.     while (!done)
  165.     {
  166.         SAFE(CBFRead(&CBFH, (STRPTR) & ID[0], 12) != -1L, failure);
  167.         switch (ID[2])
  168.         {
  169.         case ID_FTXT:
  170.             {
  171.                 SAFE(CBFRead(&CBFH, (STRPTR) & ID[0], 8) != -1L, failure);
  172.                 SAFE(ID[0] == ID_CHRS, failure);
  173.                 Snap = AllocMem(sizeof (struct Snap) + ID[1],
  174.                         MEMF_PUBLIC | MEMF_CLEAR);
  175.  
  176.                 SAFE(Snap, failure);
  177.                 Snap->Size = sizeof (struct Snap) + ID[1];
  178.  
  179.                 SAFE(CBFRead(&CBFH, (STRPTR) & Snap->Chars[0], Snap->Size) != -1L,
  180.                      failure);
  181.                 done = 1;
  182.                 break;
  183.             }
  184.         default:
  185.             {
  186.                 SAFE(CBFSeek(&CBFH, ID[1] + (ID[1] & 1) - 4, OFFSET_CURRENT),
  187.                      failure);
  188.                 break;
  189.             }
  190.         }
  191.     }
  192.     CBFEndRead(&CBFH);
  193.     return (Snap);
  194. }
  195.